`:top
`!F#`! (gelesen: `*F sharp`*; englische Aussprache []) ist eine `F33f`_`[typsichere`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Typsicherheit]`_`f Multi-`F33f`_`[Paradigmen-`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmierparadigma]`_`fSprache mit starkem Fokus auf `F33f`_`[funktionale Programmierung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Funktionale_Programmierung]`_`f für das `F33f`_`[.Net-Framework`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=.Net-Framework]`_`f. Die Syntax ähnelt der von `F33f`_`[OCaml`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Objective_CAML]`_`f sehr stark, da diese Sprache als Vorbild für die Implementierung der funktionalen und imperativen Sprachelemente diente. Im Gegensatz zu `F33f`_`[OCaml`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Objective_CAML]`_`f hat F# kein strukturiertes `F33f`_`[Typsystem`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Typisierung_(Informatik)]`_`f, sondern ein normatives, um bessere Kompatibilität mit `F33f`_`[C#`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C-Sharp]`_`f zu erreichen.
Die objektorientierte Seite von F# ist deshalb auch signifikant anders als die in OCaml.
F# ist voll interaktionsfähig mit allen anderen Sprachen des `F33f`_`[.NET`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=.NET_(Oberbegriff)]`_`f-Systems und bietet durch das `F33f`_`[.Net-Framework`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=.Net-Framework]`_`f und `F33f`_`[Mono`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Mono_(Software)]`_`f die Möglichkeit, den Code sowohl auf Windows als auch auf Linux, der `F33f`_`[BSD`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Berkeley_Software_Distribution]`_`f- und `F33f`_`[illumos`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Illumos]`_`f-Familie und `F33f`_`[macOS`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=MacOS]`_`f einzusetzen. Via `F33f`_`[Xamarin`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Xamarin]`_`f sind auch `F33f`_`[Android`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Android_(Betriebssystem)]`_`f und iOS als Zielplattformen möglich.
Ursprünglich wurde F# als Forschungsprojekt von `F33f`_`[Microsoft Research`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Microsoft_Research]`_`f entwickelt, derzeit wird es von Microsofts Entwicklungsabteilung und der F# Software Foundation fortgeführt. F# wurde als Teil von `F33f`_`[Visual Studio`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Visual_Studio]`_`f 2010 erstmals offiziell unterstützt und mit ausgeliefert.`:cite-ref-2[`F5bf`_`[2`#cite-note-2]`_`f] Im November 2010 wurde F# sowie zugehörige `F33f`_`[Compiler`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Compiler]`_`f und Bibliotheken unter der `F33f`_`[Apache-Lizenz 2.0`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Apache-Lizenz_2.0]`_`f freigegeben.
>>Contents
• `F0af`_`[Einige Sprachmerkmale`#einige-sprachmerkmale]`_`f
• `F0af`_`[Werte`#werte]`_`f
• `F0af`_`[Funktionen`#funktionen]`_`f
• `F0af`_`[Syntax`#syntax]`_`f
• `F0af`_`[Entwicklungsumgebung und Compiler`#entwicklungsumgebung-und-compiler]`_`f
• `F0af`_`[Beispiele`#beispiele]`_`f
• `F0af`_`[Literatur`#literatur]`_`f
• `F0af`_`[Weblinks`#weblinks]`_`f
• `F0af`_`[Belege`#belege]`_`f
-─
>>Einige Sprachmerkmale
>>>Werte
In überwiegend imperativen Sprachen sind `F33f`_`[Variablen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Variable_(Programmierung)]`_`f das primäre Sprachkonstrukt, um Werte zu speichern. Dies geschieht in funktional orientierten Programmiersprachen wie F# durch unveränderliche (englisch: „immutable“) Sprachkonstrukte. Mit dem häufig eingesetzten `F33f`_`[Schlüsselwort`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Schlüsselwort_(Programmierung)]`_`f `B100`F9d9let`f`b können Werte eines bestimmten Typs deklariert werden.
`B100`F9d9let pi = 3.14159265`f`b
`B100`F9d9let name = "John"`f`b
F# bietet `F33f`_`[Typableitung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Typableitung]`_`f, d. h. Typen von Ausdrücken werden automatisch ermittelt. Beispielsweise bekommt `B100`F9d9pi`f`b automatisch den Typ des `F33f`_`[Gleitkommazahl`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Gleitkommazahl]`_`f-`F33f`_`[Literals`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Literal]`_`f zugewiesen.
Veränderliche Variablen sind mit dem `B100`F9d9mutable`f`b Schlüsselwort möglich und werden mit dem Zuweisungsoperator `B100`F9d9<-`f`b verändert. Dies wird in den meisten Fällen nur selten getan, weil die beschriebene Unveränderlichkeit von Werten als passender zur Sprachphilosophie gesehen wird. Dies nennt sich in F# auch `*functional first`*, also „funktional-zuerst“.`:cite-ref-3[`F5bf`_`[3`#cite-note-3]`_`f]
`B100`F9d9let mutable x = 10`f`b
`B100`F9d9x <- 15`f`b
Werte im Nachhinein zu verändern, ist auch durch die Verwendung von sogenannten `*reference cells`* möglich:
`B100`F9d9let x = ref 0 // x hat den Typ "int ref", ist also eine Referenz auf einen Integer`f`b
`B100`F9d9x := 5 // x wird ein neuer Wert zugewiesen`f`b
`B100`F9d9printfn "%i" !x // Mittels des "!"-Operators wird x dereferenziert. Gibt 5 aus.`f`b
>>>Funktionen
Funktionen werden wie andere Werte mit `B100`F9d9let`f`b deklariert und können Parameter erwarten:
`B100`F9d9let square x = x * x`f`b
`B100`F9d9let add x y = x + y`f`b
Funktionen können Funktionen als Parameter erwarten (siehe `F33f`_`[Funktion höherer Ordnung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Funktion_höherer_Ordnung]`_`f):
`B100`F9d9let do_twice f x = f (f x)`f`b
Die Typen der Parameter werden automatisch erkannt, können aber auch explizit deklariert werden:
`B100`F9d9let add (x: int) (y: int) :int = x + y`f`b
`B100`F9d9let do_twice (f : int -> int) (x: int) = f (f x)`f`b
Die Anweisung
`B100`F9d9printfn "%A" (do_twice square 5)`f`b
gibt 625 (das Quadrat des Quadrats von 5) aus. Die Funktion `B100`F9d9do_twice`f`b kann mit Hilfe des `F33f`_`[Kompositionsoperators`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Komposition_(Mathematik)]`_`f und nach `F33f`_`[Eta-Reduktion`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Eta-Reduktion]`_`f auch als
`B100`F9d9let do_twice f = f >> f`f`b
geschrieben werden.
Im obigen Beispiel wird für `B100`F9d9square`f`b der Typ `B100`F9d9int -> int`f`b ermittelt, das heißt, `B100`F9d9square`f`b ist eine Funktion, die einen Parameter vom Typ `B100`F9d9int`f`b erwartet und einen Wert vom Typ `B100`F9d9int`f`b zurückgibt. Für `B100`F9d9do_twice`f`b erhält man den Typ `B100`F9d9('a -> 'a) -> 'a -> 'a`f`b. Dies bedeutet, `B100`F9d9do_twice`f`b ist eine Funktion, die als ersten Parameter einen Wert vom Typ `B100`F9d9('a -> 'a)`f`b (eine Funktion mit einem Parameter vom Typ `B100`F9d9'a`f`b und einem Rückgabewert vom Typ `B100`F9d9'a`f`b) bekommt. Als zweiten Parameter erhält sie einen Wert vom Typ `B100`F9d9'a`f`b und sie gibt einen Wert vom Typ `B100`F9d9'a`f`b zurück. `B100`F9d9'a`f`b hat hier die Rolle einer Typvariable (grob vergleichbar mit Generic- oder Template-Parametern in `F33f`_`[Java`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Java_(Programmiersprache)]`_`f/`F33f`_`[C++`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C++]`_`f, siehe `F33f`_`[Polymorphie (Programmierung)`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Polymorphie_(Programmierung)]`_`f).
In F# werden Parameter ohne Klammern etc., nur durch Leerzeichen getrennt, an die Funktion übergeben. Nur wenn als `F33f`_`[Parameter`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Parameter_(Informatik)]`_`f der Rückgabewert einer anderen Funktion benötigt wird, müssen Klammern gesetzt werden, um die Evaluierungsreihenfolge der Ausdrücke zu definieren. Bei `B100`F9d9printfn "%A" (add 5 8)`f`b gehören die Werte 5 und 8 zur Funktion `B100`F9d9add`f`b; deren Rückgabewert ist ein Parameter für die Funktion `B100`F9d9printfn`f`b.
F# ermöglicht `F33f`_`[Closures`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Closure_(Funktion)]`_`f und verwendet `F33f`_`[Currying`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Currying]`_`f automatisch:
`B100`F9d9let add x y = x + y`f`b
`B100`F9d9let inc = add 1`f`b
In der Definition von `B100`F9d9inc`f`b wird der erste Parameter der Funktion `B100`F9d9add`f`b an den Wert 1 gebunden. Das Ergebnis dieser partiellen Funktionsanwendung ist eine neue Funktion mit nur noch einem Parameter. Die Auswertung des Ausdrucks
`B100`F9d9inc 5`f`b
liefert als Ergebnis 6.
F# unterstützt `F33f`_`[Tupel`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Tupel_(Informatik)]`_`f:
`B100`F9d9let u = (3, 6)`f`b
`B100`F9d9let v = (2, -3)`f`b
`B100`F9d9let add (a, b) (c, d) = (a + c, b + d)`f`b
`B100`F9d9let x, y = add u v`f`b
F# bietet `*Discriminated Unions`*`:cite-ref-4[`F5bf`_`[4`#cite-note-4]`_`f] und `F33f`_`[Pattern Matching`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Pattern_Matching]`_`f:
`B100`F9d9// Ein Element vom Typ Baum ist entweder ein "Ast" und enthält zwei Elemente vom Typ "Baum",`f`b
`B100`F9d9// oder es ist ein "Blatt" und enthält einen Integer`f`b
`B100`F9d9type Baum =`f`b
`B100`F9d9| Ast of Baum * Baum`f`b
`B100`F9d9| Blatt of int`f`b
`B100`F9d9`f`b
`B100`F9d9let rec baumSumme x =`f`b
`B100`F9d9 match x with`f`b
`B100`F9d9 | Ast(l, r) -> baumSumme l + baumSumme r`f`b
`B100`F9d9 | Blatt(x) -> x`f`b
Ebenso gibt es Type Provider für die typsichere Verarbeitung externer Daten mit `F33f`_`[IntelliSense`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=IntelliSense]`_`f.`:cite-ref-5[`F5bf`_`[5`#cite-note-5]`_`f]
In F# ist auch `F33f`_`[objektorientiertes Programmieren`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Objektorientierte_Programmierung]`_`f möglich. Beispiel für eine Klassendeklaration:
`B100`F9d9type Person =`f`b
`B100`F9d9 val name : string`f`b
`B100`F9d9 val mutable age : int`f`b
`B100`F9d9 new(n, a) = { name = n; age = a }`f`b
`B100`F9d9 member x.Name = x.name`f`b
`B100`F9d9 member x.Age`f`b
`B100`F9d9 with get() = x.age`f`b
`B100`F9d9 and set(v) = x.age <- v`f`b
`B100`F9d9 member x.Print() = printfn "%s ist %i Jahre alt." x.name x.age`f`b
`F33f`_`[Nullzeiger`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Zeiger_(Informatik)]`_`f werden nur für die Interaktion mit Klassen aus dem `F33f`_`[.Net-Framework`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=.Net-Framework]`_`f benötigt.
>>Syntax
Im F#-Code sind zwei Syntaxformen möglich: einfache Syntax und ausführliche Syntax. Die einfache Syntax wird standardmäßig verwendet.
Beispiel für die einfache und ausführliche Syntax:
`t
| einfache Syntax | ausführliche Syntax |
|---|---|
| let mutable x = 1 while x < 3 do x <- x + 1 | let mutable x = 1 while x < 3 do x <- x + 1 done |
| type Person = val name : string val mutable age : int | type Person = class val name : string val mutable age : int end |
`t
Bei der einfachen Syntax sind die Einrückungen zwingend erforderlich, bei der ausführlichen könnte man sie auch weglassen.
>>Entwicklungsumgebung und Compiler
F#-Code wird `F33f`_`[kompiliert`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Compiler]`_`f, hierbei entsteht `F33f`_`[Zwischencode`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Zwischencode]`_`f in der `F33f`_`[Common Intermediate Language`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Common_Intermediate_Language]`_`f (CIL), genau wie bei Programmen, die in `F33f`_`[C#`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C-Sharp]`_`f oder `F33f`_`[VB.NET`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=VB.NET]`_`f geschrieben wurden.
Es gibt auch eine interaktive Umgebung bzw. F#-`F33f`_`[Interpreter`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Interpreter]`_`f, F# Interactive oder kurz FSI. Damit kann man den Code direkt in der `F33f`_`[Konsole`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Kommandozeile]`_`f schreiben. Eingaben im Interpreter sind mit `B100`F9d9;;`f`b abzuschließen, wodurch auch mehrzeilige Eingaben ermöglicht werden. Nach dem Kompilieren führt F# Interactive den Code aus und schreibt die Signatur aller kompilierten Typen und Werte in das Konsolenfenster. Auch Fehlermeldungen werden so ausgegeben.`:cite-ref-6[`F5bf`_`[6`#cite-note-6]`_`f]
Dieser Interpreter erlaubt in unterstützten Editoren wie `F33f`_`[Visual Studio Code`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Visual_Studio_Code]`_`f die Ausführung von Code ohne vorherige Kompilierung, so wie dies von dynamischen Sprachen bekannt ist.
Außerdem gibt es den Fable`:cite-ref-7[`F5bf`_`[7`#cite-note-7]`_`f]-Übersetzer, mit dessen Hilfe sich F#-Code in `F33f`_`[JavaScript`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=JavaScript]`_`f, `F33f`_`[Rust`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Rust_(Programmiersprache)]`_`f, `F33f`_`[Python`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Python_(Programmiersprache)]`_`f, `F33f`_`[PHP`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=PHP]`_`f und `F33f`_`[Dart`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Dart_(Programmiersprache)]`_`f übersetzen lässt.
>>Beispiele
Folgende Beispiele geben „`F33f`_`[Hello World`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Hello_World]`_`f“ aus.
`B100`F9d9let main = System.Console.WriteLine("Hello World")`f`b
oder
`B100`F9d9printfn "Hello World"`f`b
Die folgende Funktion implementiert die rekursive `F33f`_`[Ackermannfunktion`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Ackermannfunktion]`_`f:
`B100`F9d9let rec ack m n =`f`b
`B100`F9d9 if m = 0 then n + 1`f`b
`B100`F9d9 else if n = 0 then ack (m - 1) 1`f`b
`B100`F9d9 else ack (m - 1) (ack m (n - 1))`f`b
>>Literatur
• Oliver Sturm: `*F# Einstieg und praktische Anwendung`*. entwickler.press, 2012, ISBN 978-3-86802-083-0.
>>Weblinks
• `*The F# Software Foundation.`* Abgerufen am 5. Juni 2014 (englisch).
• `*F# Dokumentation.`* In: `*Microsoft Docs.`* Microsoft, abgerufen am 27. April 2014.
• `*F# compiler, Basisbibliothek und Tools auf GitHub.`* Abgerufen am 9. Juni 2020 (englisch).
• `*F# at Microsoft Research.`* Microsoft Research, abgerufen am 27. April 2014 (englisch, F#-Homepage von Microsoft Research).
• `*The F# Survival Guide.`* CTO Corner, archiviert vom Original am 15. Juli 2011; abgerufen am 27. April 2014 (englisch).
• `*F# Cheatsheet.`* In: `*Github.`* Abgerufen am 9. Juni 2020 (englisch).
• Scott Wlaschin: `*Twenty six low-risk ways to use F# at work.`* In: `*F# for fun and profit.`* 20. April 2014, abgerufen am 9. Juni 2020 (englisch).
• `*Try F#.`* F# Software Foundation, abgerufen am 9. Juni 2020 (englisch). Interaktives Tutorial.
>>Belege
`:cite-note-1`!1.`! `*Announcing F# 7.`* 9. November 2021, abgerufen am 14. September 2023 (amerikanisches Englisch).
`:cite-note-2`!2.`! `F0af`_`[↑`#cite-ref-2]`_`f `*F# to ship as part of Visual Studio 2010`*. Don Syme’s WebLog on the F# Language and Related Topics
`:cite-note-3`!3.`! `F0af`_`[↑`#cite-ref-3]`_`f `*Functional-first Programming with F#.`* Abgerufen am 14. September 2023 (amerikanisches Englisch).
`:cite-note-4`!4.`! `F0af`_`[↑`#cite-ref-4]`_`f Unterscheidungs-Unions, auf learn.microsoft.com
`:cite-note-5`!5.`! `F0af`_`[↑`#cite-ref-5]`_`f Type Provider
`:cite-note-6`!6.`! `F0af`_`[↑`#cite-ref-6]`_`f Microsoft F# Interactive-Referenz
`:cite-note-7`!7.`! `F0af`_`[↑`#cite-ref-7]`_`f `*Fable · JavaScript you can be proud of!`* Abgerufen am 14. September 2023.
`c`F0af`_`[↑ Back to top`#top]`_`f`a